1. Field
This disclosure relates to computer programming in a World Wide Web environment and, more specifically, to systems and methods relating to a component oriented software design approach in a document oriented user interface environment.
2. Background
Current technologies for developing World Wide Web-related software applications can pose significant challenges to programmers. Such challenges concern interoperability, usability and maintainability. World Wide Web-related applications often require a document-oriented approach to designing user interfaces, while other types of software applications often require a component-oriented design approach. As will be explained below, document-oriented programming and component-oriented programming follow different, and sometimes conflicting, procedures.
The World Wide Web (“Web”) includes a system of Internet servers that support specially formatted documents. The documents are often called “Web pages.” Every Web page is identified by a unique Uniform Resource Locator (“URL”). Web pages are typically created in a “mark-up” computer language, such as HyperText Mark-up language (“HTML”), Extensible Mark-up Language (“XML”) or the like, that supports links to other documents, graphics, audio, and video files. A “mark-up language” is a computer language that describes how a page should be formatted by using specialized “tags.” An HTML tag is a code element that tells a Web browser what to do with text. Mark-up languages also enable a person accessing content on the Web to jump from one document to another simply by clicking on links that are embedded within Web pages. Specialized software applications called Web browsers (“browsers”) allow users to access the Web, and to retrieve and interact with documents on it. Browsers are typically capable of parsing HTML and retrieving Web pages using Hypertext Transfer Protocol (“HTTP”), File Transfer Protocol (“FTP”), and other protocols used to transfer information over networks. Two popular browsers are NETSCAPE NAVIGATOR and MICROSOFT INTERNET EXPLORER. Both are graphical browsers, meaning they can display graphics as well as text. To display graphics, such as images, software objects, and the like, the browser must be able to “render” the graphic. A Web browser is able to interpret the set of mark-up language tags within a page in order to display the page on your screen as the page's creator intended it to be viewed. Unfortunately, presenting certain types of information, and supporting certain interactions with a document pose challenges to the traditional rendering processes.
Software applications and documents that are accessible on the Web are often constructed from a set of software components, in accordance with a component software development paradigm. A “component” is typically a small binary object or program that performs a specific function. It is often designed in such a way as to easily operate with other components and applications. A set of interacting components may constitute a software application. The user interface for a software application may be implemented with UI components that include a visual representation and control element that handles interactions between the component's representation and the user. Certain classes of UI components may also be represented in documents that are available via the Internet. Thus, when a user accesses a Web page or other document with his browser, the browser renders the visual representation of each component contained in the document so that the components can be displayed to the user. Components may include controls that a user can interact with, such as tables, text boxes, and other user-interactive items. A control is typically a software-based item that can be individually selected and manipulated by a user.
Typically, Web pages are stored on large server machines. These machines may be accessed by individuals operating smaller client machines such as personal computers. When a user accesses a server Web page through a browser installed on his client machine, the browser typically retrieves the page from the server, and renders the page on the user's own client machine, so that the page can be viewed by the user. If the Web page comprises component representations, each component must be rendered by the browser. However, when a Web page includes component representations that a user can interact with, rather than merely static information, the content on a page may undergo changes after the page and its component representations have been displayed to the user. For example, a Web page may include a table component. Whenever the user interacts with a component representation in the server Web page, such as by manipulating data in the table, that component's state must be updated to reflect this interaction. The state change in the component could trigger addition state changes that must be ultimately reflected in the component representation on the user's display screen. These changes need to be shown to the user, but are often difficult to coordinate on an on-going basis, as a user continues to interact with the component, and component state changes are communicated back to the server. Currently, many Web applications rely on fetching from the server, in the form of mark-up language strings, then re-rendering an entire document upon every significant user event. Due to network latency and inherent rendering time, even the simplest updates to a component can cause significant inefficiencies and delays. Also, side effects from the delays including lost input focus and scrollbar position between page refreshes can occur during re-rendering. These can lead to reduced usability from a user's perspective. The process of converting components to mark-up language strings before rendering them, as well as the process of re-rendering an entire Web page upon user-interaction with only one component or portion of that page, can be tedious, cumbersome and time consuming. Furthermore, business logic state changes at the server that cause state changes in UI components cannot be asynchronously communicated to the component representation, and can only be realized when the page is refreshed after some user interaction with the component representation at the client.
In order to reduce the need for interacting with server-based documents and engage in time-consuming re-rendering, some Web applications have been designed to extend client-side capabilities so that updates may occur on the client itself. Specialized programming languages such as Dynamic HTML (“DHTML”) and JavaScript enable some degree of client-side operability. DHTML refers generally to Web content that is capable of being changed while it is being viewed. JavaScript is a programming language technology, called a scripting language, for manipulating DHTML. JavaScript enables Web authors to design interactive Web sites that include controls with which users interact. JavaScript can interact with HTML source code, enabling Web authors to enhance Web pages with dynamic interactive state. While usability of client-side Web applications may be improved through the use of DHTML and JavaScript, interoperability and maintenance of such Web applications have often been impeded by such methods. One reason for this is that JavaScript is not inherently portable. As a result, incompatibilities between different machines in communication with one another can manifest when components within a document or application break down. For example, different software vendors often employ incompatible standards for JavaScript execution, and a single vendor may often support different JavaScript versions. One result of these incompatibilities is that JavaScript code relies on customized code for each combination of supported browser vendor and software version, and often cannot be easily maintained on a client machine. A Web application may be rendered completely unusable when a single component fails to operate due to an incompatibility.
In short, programmers can currently face significant challenges when designing user interfaces for component-based applications created for a networked Web-like environment. The ability to efficiently render updated versions of component-based applications and documents following user input to a user interface to those applications and documents is often significantly limited.